//1.普通类
class Person{
    //字段——》属性——》成员变量
    public String name;
    public int age;
    //方法——》行为
    public void eat(){
        System.out.println(name + "正在吃饭");
    }

    public void sleep(){
        System.out.println(name + "正在睡觉");
    }
}
//2.静态类
class Stu{
    //静态成员变量也叫类变量，在方法区存储
    //这个变量是类的，不是对象的
    public static int age;

    public int id;

    public static void staticFunc(){
        //静态方法内不能访问非静态变量
        //id = 1;
        //也不能调用普通方法
        //eat();
        System.out.println("一个静态方法");
    }

    public void eat(){
        //普通方法内不能创建静态变量,因为在方法内部是局部变量
        //static int id = 1;
        //但是可以调用静态方法
        staticFunc();
    }

    //这样创建对象就是在堆上创建的，所以对象不都是在栈上。
    Person person = new Person();

    //toString方法，用于改变println的输出

    @Override
    public String toString() {
        return "Stu{" +
                "id=" + id +
                '}';
    }
}
//3.封装
class Tea{
    private String name;
    private int age;

    //get和set方法来赋值与获取
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Tea{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//4.构造方法
class Peop{
    //构造方法是用来创建对象的
    public String name;
    public int age;

    public Peop(){
        this(18);//指的是调用含age的构造方法,只能在构造方法中
        //this("zjk", 18);this()必须要放第一个
        System.out.println("无参的构造方法");
    }
    public Peop(int age){
        this.age = age;//this代表当前对象的引用
        System.out.println("带一个参");
    }
    public Peop(String name, int age){
        this.age = age;
        this.name = name;
        System.out.println("带二个参");
    }

    @Override
    public String toString() {
        return "Peop{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//5.代码块
class Map{
    //代码块优先调用，静态代码块最优
    {
        System.out.println("实例代码块");
    }

    static {//静态代码块，不用实例化就可以执行，但是main函数要有内容，且只会执行一次
        //静态代码块只能赋值静态的变量
        System.out.println("静态代码块");
        age = 99;
    }
    public static int age = 10;//age的值与创建顺序有关，但未初始化优先看static内

}

public class TestDemo {

    public static void main6(String[] args) {
        //匿名对象(只能用一次)
        new Person().sleep();
        new Person().eat();
        System.out.println(new Person());
    }

    public static void main5(String[] args) {
        Map map = new Map();
        System.out.println(Map.age);
        Map map1 = new Map();//第二次静态代码块不执行，只执行一次
    }

    public static void main4(String[] args) {
        Peop peop = new Peop();
        Peop peop1 = new Peop(18);
        Peop peop2 = new Peop("zjk", 18);
    }

    public static void main3(String[] args) {
        Tea tea = new Tea();
        tea.setAge(18);
        tea.setName("zjk");
        System.out.println(tea);
    }

    public static void main2(String[] args) {
        /*Stu stu = new Stu();
        stu.age++;*/
        Stu.age++;

        /*Stu stu1 = new Stu();
        stu1.age++;*/
        Stu.age++;

        Stu.staticFunc();

        Stu stu = new Stu();
        stu.id = 18;
        System.out.println(stu);
    }

    public static void main1(String[] args) {
        //通过new来实例化对象
        Person person = new Person();//每个对象都有自己的空间
        //person是一个变量，里面存放着地址，通过地址在堆内找到对应内存
        Person person1 = new Person();
        person.name = "gaobo";
        System.out.println(person.name);
        System.out.println(person1.name);//null
        System.out.println(person.age);//0
        person.eat();
        person1.sleep();
    }
}
